﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GEAR_Structure.UNI.Energy
{
    static class UniEnIso6946
    {
        

      

        /// <summary>
        /// Data la resistenza termica totale restituisce la trasmittanza, Data la trasmittanza (o la conduttanza) restituisce la resistenza termica totale (o del singolo strato)
        /// </summary>
        /// <param name="Val">Resistenza termica totale del compnente edilizio complessiva di coeficienti liminari [m²K/W] o trasmittanza [W/(m²K)] o conduttanza [W/(m²K)]</param>
        /// <returns>Restituisce l'inverso del valore passato Trasmittanza U in [W/(m²K)]o Resistenza termica Rter in [m²K/W]</returns>
        public static double Invers(double Val)
        {
            return 1 / Val;
        }

        /// <summary>
        /// Calcola la conducibilità equivalente in [W/(mK)]
        /// </summary>
        /// <param name="l">oggetto layer </param>
        /// <returns>Conducibilità equivalente in [W/(mK)]</returns>
        public static double conductivity_equivalent(Materiale l)
        {
            return l.Conduttance * l.Tickness;
        }

        /// <summary>
        /// Calcola la conducibilità equivalente in [W/(mK)]
        /// </summary>
        /// <param name="s">apessore dello strato in [m]</param>
        /// <param name="conduttanza">conduttanza dello strato in [W/(m²K)] </param>
        /// <returns>Conducibilità equivalente in [W/(mK)]</returns>
        public static double conductivity_equivalent(double _thickness_layer, double _conductance)
        {
            return _thickness_layer * _conductance;

        }
        /// <summary>
        /// Calcola la conduttanza 
        /// </summary>
        /// <param name="l">oggetto layer</param>
        /// <returns>conduttanza</returns>
        public static double conductance(Materiale m)
        {
            return m.Conductivity / m.Tickness;
        }
        /// <summary>
        /// restituisce la massa superficiale del materiale
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        public static double LayerSurfaceMass(Materiale m)
        {
            return m.Tickness * m.Density;
        }

        /************************************************************************************************************************************************
      //Calcolo della Resistenza termica totale della parete questa può essere calcolato con i coeficienti liminari o senza i coeficienti liminari
      //l'inverso della Rtot senza i liminari da la "Conduttanza Specifica Equivalente" [W/(m²K)] mentre l'inverso della Rtot con i liminari Rsi e Rse
      //da la trasmittanza termica in [W/(m²K)]
      *************************************************************************************************************************************************/

        /// <summary>
        /// Calcola la resistenza termica del singolo stratto in [m²K/W]
        /// </summary>
        /// <param name="Spessore">Spessore dello strato in [m]</param>
        /// <param name="Conducibilita">Conducibilità rtermica del materiale che costituisce lo strato in [W/(mK)]</param>
        /// <returns>Resistenza termica dello strato in [m²K/W]</returns>
        public static double Rtot(double Spessore, double Conducibilita)
        {
            double Rs = 0;

            return Rs = Spessore / Conducibilita;
        }
        /// <summary>
        /// Calcola la resistenza termica del singolo stratto in [m²K/W]
        /// </summary>
        /// <param name="m">materiale di cui calcolare la resistenza termica</param>
        /// <returns>Resistenza termica dello strato in [m²K/W]</returns>
        public static double Rtot(Materiale m)
        {
            return m.Tickness / m.Conductivity;
        }
        /// <summary>
        /// Calcola la resistenza termica della parete in [m²K/W]
        /// </summary>
        /// <param name="nstrati">numero degli strati che costituiscono la parete</param>
        /// <param name="SpesCond">spessore degli strati[m], conducibilità degli strati[W/(mK)] (spessore e conducibilità nello stesso ordine)</param>
        /// <returns>Restituisce la resistenza termica totale il cui inverso da la conduttanza </returns>
        public static double Rtot(int nstrati, double[,] SpesCond)
        {
            double Rtot = 0;
            int i;

            for (i = 0; i < nstrati; i++)
            {

                Rtot += (SpesCond[i, 0]) / (SpesCond[i, 1]);

            }



            return Rtot;
        }
       /*
        /// <summary>
        /// Calcola la resistenza termica totale della parete
        /// </summary>
        /// <param name="str">oggetto list Layer - lista degli strati che compongono l'elemento costruttivo</param>
        /// <returns>Resistenza Termica Totale</returns>
        public static double Rtot(List<Layer> str)
        {
            double Rtot = 0;
            foreach (Layer l in str)
                Rtot += l.Thickness_layer / l.Conductivity;
            return Rtot;
        }
        */
        /// <summary>
        /// Calcola la resistenza termica dell'elemento ssenza liminari
        /// </summary>
        /// <param name="str">stratigrafia dell'elemento considerato</param>
        /// <returns>Rtot [m²K/W]</returns>
        public static double Rtot(Stratigraphy str)
        {
            double Rtot = 0;
            foreach (Materiale m in str.Layers)
                Rtot += m.Tickness / m.Conductivity;
            return Rtot;
        }
        /// <summary>
        /// Calcola la resistenza termica totale dell'elemento copresi i liminari
        /// </summary>
        /// <param name="str"></param>
        /// <returns>Rtot [m²K/W]</returns>
        public static double RtotEnvironment(Stratigraphy str)
        {
            return str.Rsi + str.Rse + Rtot(str); ;
        }
        /// <summary>
        /// Calcola la resistenza termica totale della parete compresa di stratti liminari in [m²K/W] , i liminari devono essere passatti 
        /// </summary>
        /// <param name="nstrati">numero degli strati che costituiscono la parete cioè strato liminare interno ed esterno)</param>
        /// <param name="SpesCond">spessore degli strati[m], conducibilità degli strati[W/(mK)] (spessore e conducibilità nello stesso ordine)</param>
        /// <param name="Rsi">Resistenza liminare interna in [m²K/W]</param>
        /// <param name="Rse">Resistenza liminare esterna in [m²K/W]</param>
        /// <returns>Restituisce la resistenza termica totale compresa di liminari il cui inverso da la trasmittanza</returns>
        public static double Rtot(int nstrati, double[,] SpesCond, double Rsi, double Rse)
        {
            double Rtot = 0;
            int i;

            for (i = 0; i < nstrati; i++)
            {

                Rtot += (SpesCond[i, 0]) / (SpesCond[i, 1]);

            }

            Rtot = Rtot + Rsi + Rse;

            return Rtot;
        }
        /// <summary>
        /// Calcola la resistenza totale della parete compresa di liminari
        /// </summary>
        /// <param name="Rt">Resistenza termica della parete</param>
        /// <param name="Rsi">Resistenza superficiale interna</param>
        /// <param name="Rse">Resistenza superficiale esterna</param>
        /// <returns>Resistenza totale con liminari</returns>
        public static double Rtot(double Rt, double Rsi, double Rse)
        {
            double Rtot = 0;
            Rtot = Rsi + Rt + Rse;
            return Rtot;
        }
        /// <summary>
        /// Calcola la resistenza termica totale del componente edilizio assegnando i coeficienti liminari in funzione del flusso termico e del componente edilizio
        /// </summary>
        /// <param name="VersoTipo">Tipologia del componente edilizio (verso cosa confina?) il valore  va da 1 a 9</param>
        /// <param name="Rtot">Resistenza termica del componente senza i coeficienti liminari (Rsi ed Rse)</param>
        /// <returns>Restituisce la resistenza termica totale Rtot conplessiva delle resistenze liminari (Rsi ed Rse) clcolate in funzione del tipo di componente</returns>
        public static double Rtot(int VersoTipo, double Rtot)
        {
            double Rsi = 0, Rse = 0;

            switch (VersoTipo)
            {
                case (1): //Parete verticale opaca verso esterno flusso termico orizontale
                    Rsi = 0.13;
                    Rse = 0.04;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (2)://Parete verticale opaca verso terreno flusso termico orizontale

                    Rsi = 0.13;
                    Rse = 0;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (3)://Parete verticale opaca verso interno flusso termico orizontale

                    Rsi = 0.13;
                    Rse = 0.13;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (4)://Pavimento contro terra direzione flusso verso il basso

                    Rsi = 0.17;
                    Rse = 0;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (5)://Pavimento su spazio areato esterno direzione flusso verso il basso

                    Rsi = 0.17;
                    Rse = 0.04;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (6)://Pavimento su spazio areato interno direzione flusso verso il basso

                    Rsi = 0.17;
                    Rse = 0.17;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (7)://Solaio orizzontale verso esterno direzione flusso verso l'alto

                    Rsi = 0.10;
                    Rse = 0.04;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (8)://Solaio orizzontale verso terreno (tetto giardino) direzione flusso verso l'alto

                    Rsi = 0.10;
                    Rse = 0.00;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                case (9)://Solaio orizzontale verso ambiente interno direzione flusso verso l'alto

                    Rsi = 0.10;
                    Rse = 0.10;
                    Rtot = Rtot + Rsi + Rse;
                    break;
                default://se non è presente il versotipo
                    Rtot = 0;
                    break;





            }



            return Rtot;
        }
        /// <summary>
        /// Calcola la resistenza totale o parziale della parete compressiva o meno dei liminari in finzione dell'array passato
        /// </summary>
        /// <param name="SpesCond">Array con indicante spessore degli strati[m], conducibilità degli strati[W/(mK)] (spessore e conducibilità nello stesso ordine) è possibile passare anche le resistenze liminari in questo caso andra posta la conducibilità =1</param>
        /// <returns>Resistenza termica componente</returns>
        public static double Rtot(double[,] SpesCond)
        {

            int nstrati = SpesCond.GetLength(0);
            int i;
            double Rtot = 0;
            for (i = 0; i < nstrati; i++)
            {

                Rtot += (SpesCond[i, 0]) / (SpesCond[i, 1]);

            }
            return Rtot;
        }



        /*************************************************************************************************************
      * Calcolo la difusività ed efusività termica del materiale
      * 
      ************************************************************************************************************/

        /// <summary>
        /// Calcola la difusività termica "a" in [m²/s]
        /// </summary>
        /// <param name="conducibilita">conducibilità termica del materiale considerato in [W/(mK)]</param>
        /// <param name="rho">Massa volumica del materiale (densità) in [kg/m³]</param>
        /// <param name="Cp">Calore specifico a pressione costante in [J/(kgK)]</param>
        /// <returns>Restituisce la difuzività termica del materiale</returns>
        public static double thermal_diffusivity(double _conductivity, double _density, double _specific_heat)
        {
            double a;
            return a = _conductivity / (_density * _specific_heat);

        }
        /// <summary>
        /// Calcola la difusività termica "a" in [m²/s]
        /// </summary>
        /// <param name="m">materiale di cui calcolare la difusività termica</param>
        /// <returns>difusivita termica [m²/s]</returns>
        public static double thermal_diffusivity(Materiale m)
        {
            
            return m.Conductivity / (m.Density * m.SpecificHeat);

        }
        /// <summary>
        /// Calcola l'efusività termica "e" in [J/(K²s¹'²)]
        /// </summary>
        /// <param name="conducibilita">conducibilità termica del materiale considerato in [W/(mK)]</param>
        /// <param name="rho">Massa volumica del materiale (densità) in [kg/m³]</param>
        /// <param name="Cp">Calore specifico a pressione costante in [J/(kgK)]</param>
        /// <returns>Restituisce l'efusività termica del materiale</returns>
        public static double thermal_effusivity(double _conductivity, double _density, double _specific_heat)
        {
            double e;
            return e = _conductivity * _density * _specific_heat;

        }
        /// <summary>
        /// Calcola l'efusività termica "e" in [J/(K²s¹'²)]
        /// </summary>
        /// <param name="m">materiale di cui calcolare l'efusività termica</param>
        /// <returns>Restituisce l'efusività termica del materiale [J/(K²s¹'²)]</returns>
        public static double thermal_effusivity(Materiale m)
        {

            return m.Conductivity * m.Density * m.SpecificHeat;

        }
    }
}
